#include<iostream>
#include<string>
#include<algorithm>
#include<assert.h>
using namespace std;
namespace Myvector
{
    template<class T>
    class vector
    {
    public:
        typedef T* iterator;
        typedef const T* const_iterator;
        iterator begin()
        {
            return _start;
        }
        iterator end()
        {
            return _finish;
        }
        const_iterator begin()const
        {
            return _start;
        }
        const_iterator end()const
        {
            return _finish;
        }
        //只要是构造函数一定要用初始化列表给成员变量初始化，自定义类型用初始化列表初始化，内置类型可以在声明中给缺省值
        //没有初始化就是找错误找半天，他妈的找了一下午错，靠！！！
        //普通构造函数
        vector()
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
        {
            cout<<"vector()"<<endl;
        }
        //n个val的构造函数
        vector(size_t n, const T& val = T())
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
		{
			resize(n, val);
		}

		vector(int n, const T& val = T())
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
		{
			resize(n, val);
		}
        template<class inputiterator>
        vector(inputiterator first,inputiterator last)
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endofstorage(nullptr)
        {
            while(first!=last)
            {
                push_back(*first);
                first++;
            }
        }
        //析构函数
        ~vector()
        {
            cout<<"~vector()"<<endl;
            if(_start)
            {
                delete[] _start;
                _start=_finish=_endofstorage=nullptr;
            }
        }
        //拷贝构造函数
        vector(const vector<T>& v)
        {
            _start=new T[v.capacity()];
            for(size_t i=0;i<v.size();i++)
            {
                _start[i]=v._start[i];
            }
            _finish=_start+v.size();
            _endofstorage=_start+v.capacity();
        }

        void Swap(vector<T>& v)
        {
            swap(_start,v._start);
            swap(_finish,v._finish);
            swap(_endofstorage,v._endofstorage);
        }
        //赋值运算符重载函数
        vector<T>& operator=(vector<T> v)
        {
            Swap(v);
            return *this;
        }

        size_t size()const
        {
            return _finish-_start;
        }
        size_t capacity()const
        {
            return _endofstorage-_start;
        }

        T& operator[](size_t pos)
        {
            assert(pos<size());
            return _start[pos];

        }
        const T& operator[](size_t pos)const
        {
            assert(pos<size());
            return _start[pos];

        }

        void reserve(size_t n)
        {
            if(n>capacity())
            {
                size_t sz=size();
                T* tmp=new T[n];
                if(_start){
                    //这里拷贝数据时，如果T是自定义类型，比如sring，直接使用memcpy会是浅拷贝，所以要用赋值深拷贝
                    for(size_t i=0;i<sz;i++)
                    {
                        tmp[i]=_start[i];
                    }
                    delete[] _start;
                }
                _start=tmp;
                _finish=_start+sz;
                _endofstorage=_start+n;
            }
        }

        //T()是匿名对象缺省值，如果T是自定义类型会调用对应的构造函数创建匿名对象
        //c++对内置类型进行了升级，也可以使用构造函数初始化
        //int i=0;     int j=int();      int k=int(1);

        void resize(size_t n,const T& val=T())
        {
            if(n<size())
            {
                _finish=_start+n;
            }
            else
            {
                reserve(n);
                while(_finish!=_start+n)
                {
                    *_finish=val;
                    _finish++;
                }
            }
        }
        void push_back(const T& x)
        {
            /*if(_finish==_endofstorage){
                size_t newcpacity=capacity()==0?4:2*capacity();
                reserve(newcpacity);
            }
            *_finish=x;
            _finish++;*/
            insert(end(),x);
        }

        iterator insert(iterator pos,const T& x)
        {
            assert(pos >= _start && pos <= _finish);
            //先记录pos的位置，防止扩容后迭代器失效
            if(_finish==_endofstorage)
            {
                size_t len=pos-_start;
                size_t newcapacity=capacity()==0?4:2*capacity();
                reserve(newcapacity);
                pos=_start+len;
            }
            //扩容后，更新pos的位置，让po指向新的空间中的位置
            iterator end=_finish-1;
            while(end>=pos)
            {
                *(end+1)=*end;
                end--;
            }
            *pos=x;
            ++_finish;
            return pos;
        }

        iterator erase(iterator pos)
        {
            assert(pos>=_start&&pos<=_finish);
            iterator it=pos+1;
            while(it!=_finish)
            {
                *(it-1)=*it;
                it++;
            }
            _finish--;
            return pos;
        }

        void pop_back()
        {
            erase(end()-1);
        }




    private:
        iterator _start;
        iterator _finish;
        iterator _endofstorage;

    };
}